const axios = require('axios');
require('dotenv').config();

class CozeClient {
  constructor() {
    this.apiKey = process.env.COZE_API_KEY;
    this.baseURL = process.env.COZE_API_BASE_URL;
    this.client = axios.create({
      baseURL: this.baseURL,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: 30000 // 30秒超时
    });

    // 智能体ID映射表
    this.botIds = {
      designBot: 'design-bot-id', // 教学设计智能体ID
      imageBot: 'image-bot-id',   // 图像生成智能体ID
      videoScriptBot: 'video-script-bot-id', // 视频脚本优化智能体ID
      videoBot: 'video-bot-id',   // 视频生成智能体ID
      exerciseBot: 'exercise-bot-id', // 练习题生成智能体ID
      paperBot: 'paper-bot-id',   // 试卷生成智能体ID
      paperValidateBot: 'paper-validate-bot-id', // 试卷校验智能体ID
      customBot: 'custom-bot-id'  // 个性化定制智能体ID
    };
  }

  /**
   * 调用Coze智能体
   * @param {string} botType - 智能体类型，对应botIds中的键
   * @param {object} params - 传递给智能体的参数
   * @param {object} options - 额外选项
   * @returns {Promise<object>} - 智能体返回的结果
   */
  async callBot(botType, params, options = {}) {
    try {
      const botId = this.botIds[botType];
      if (!botId) {
        throw new Error(`未知的智能体类型: ${botType}`);
      }

      // 构建请求体
      const requestBody = {
        bot_id: botId,
        query: this.formatQuery(params),
        ...options
      };

      // 发送请求到Coze API
      const response = await this.client.post('/v1/chat/completions', requestBody);
      
      // 处理响应
      return this.processResponse(response.data, botType);
    } catch (error) {
      console.error(`调用Coze智能体失败 (${botType}):`, error.message);
      if (error.response) {
        console.error('响应状态:', error.response.status);
        console.error('响应数据:', error.response.data);
      }
      throw new Error(`调用Coze智能体失败: ${error.message}`);
    }
  }

  /**
   * 格式化查询参数为智能体可接受的格式
   * @param {object} params - 参数对象
   * @returns {string} - 格式化后的查询字符串
   */
  formatQuery(params) {
    // 根据不同智能体类型，可以有不同的格式化逻辑
    if (typeof params === 'string') {
      return params;
    }
    
    // 将对象转换为结构化的提示文本
    return Object.entries(params)
      .map(([key, value]) => {
        // 处理数组或对象类型的值
        if (typeof value === 'object' && value !== null) {
          value = JSON.stringify(value);
        }
        return `${key}: ${value}`;
      })
      .join('\n');
  }

  /**
   * 处理智能体响应
   * @param {object} responseData - 智能体返回的原始数据
   * @param {string} botType - 智能体类型
   * @returns {object} - 处理后的结果
   */
  processResponse(responseData, botType) {
    // 基本响应检查
    if (!responseData || !responseData.choices || !responseData.choices.length) {
      throw new Error('智能体返回了无效的响应格式');
    }

    const content = responseData.choices[0].message.content;
    
    // 尝试解析JSON响应
    try {
      // 检查是否是JSON字符串
      if (content.trim().startsWith('{') && content.trim().endsWith('}')) {
        return JSON.parse(content);
      }
    } catch (e) {
      // 如果不是有效的JSON，继续使用原始内容
      console.log('响应不是有效的JSON格式，使用原始内容');
    }

    // 根据不同的智能体类型进行特定处理
    switch (botType) {
      case 'designBot':
        return this.processDesignBotResponse(content);
      case 'imageBot':
        return this.processImageBotResponse(content, responseData);
      case 'exerciseBot':
        return this.processExerciseBotResponse(content);
      case 'paperBot':
        return this.processPaperBotResponse(content);
      default:
        // 默认返回原始内容
        return { content };
    }
  }

  /**
   * 处理教学设计智能体的响应
   * @param {string} content - 响应内容
   * @returns {object} - 结构化的教学设计
   */
  processDesignBotResponse(content) {
    // 尝试从文本中提取结构化信息
    // 这里是一个简单的示例，实际实现可能需要更复杂的解析逻辑
    const design = {
      title: this.extractSection(content, '标题', '教学目标'),
      objectives: this.extractSection(content, '教学目标', '教学重点'),
      keyPoints: this.extractSection(content, '教学重点', '教学难点'),
      difficultyPoints: this.extractSection(content, '教学难点', '教学方法'),
      methods: this.extractSection(content, '教学方法', '教学过程'),
      process: this.extractSection(content, '教学过程', '教学评价'),
      evaluation: this.extractSection(content, '教学评价', null),
      rawContent: content
    };

    return design;
  }

  /**
   * 处理图像生成智能体的响应
   * @param {string} content - 响应内容
   * @param {object} fullResponse - 完整响应对象
   * @returns {object} - 包含图像URL的对象
   */
  processImageBotResponse(content, fullResponse) {
    // 从响应中提取图像URL
    // 注意：实际的Coze API可能有不同的响应格式
    let imageUrl = '';
    
    // 尝试从完整响应中提取图像URL
    if (fullResponse.choices[0].message.image_urls && 
        fullResponse.choices[0].message.image_urls.length > 0) {
      imageUrl = fullResponse.choices[0].message.image_urls[0];
    } else {
      // 尝试从内容中提取URL
      const urlMatch = content.match(/https?:\/\/[^\s"']+\.(jpg|jpeg|png|gif|svg)/i);
      if (urlMatch) {
        imageUrl = urlMatch[0];
      }
    }

    return {
      imageUrl,
      description: content,
      generatedAt: new Date().toISOString()
    };
  }

  /**
   * 处理练习题生成智能体的响应
   * @param {string} content - 响应内容
   * @returns {object} - 结构化的练习题
   */
  processExerciseBotResponse(content) {
    // 尝试解析练习题内容
    // 这里假设智能体返回的是结构化的练习题列表
    const exercises = [];
    
    // 使用正则表达式匹配题目
    const questionPattern = /题目\s*(\d+)[.：:]\s*([\s\S]*?)(?=选项|答案|解析|题目\s*\d+|$)/g;
    const optionsPattern = /选项[.：:]\s*([\s\S]*?)(?=答案|解析|题目\s*\d+|$)/;
    const answerPattern = /答案[.：:]\s*([\s\S]*?)(?=解析|题目\s*\d+|$)/;
    const analysisPattern = /解析[.：:]\s*([\s\S]*?)(?=题目\s*\d+|$)/;
    
    let match;
    while ((match = questionPattern.exec(content)) !== null) {
      const questionNumber = match[1];
      const questionText = match[2].trim();
      
      // 提取当前题目后面的内容
      const remainingContent = content.substring(match.index + match[0].length);
      
      // 提取选项
      const optionsMatch = remainingContent.match(optionsPattern);
      const optionsText = optionsMatch ? optionsMatch[1].trim() : '';
      
      // 解析选项为对象
      const options = {};
      const optionLines = optionsText.split('\n');
      optionLines.forEach(line => {
        const optionMatch = line.match(/([A-Z])[.．、]\s*(.+)/);
        if (optionMatch) {
          options[optionMatch[1]] = optionMatch[2].trim();
        }
      });
      
      // 提取答案
      const answerMatch = remainingContent.match(answerPattern);
      const answer = answerMatch ? answerMatch[1].trim() : '';
      
      // 提取解析
      const analysisMatch = remainingContent.match(analysisPattern);
      const analysis = analysisMatch ? analysisMatch[1].trim() : '';
      
      exercises.push({
        number: parseInt(questionNumber),
        question: questionText,
        options,
        answer,
        analysis
      });
    }
    
    return {
      exercises,
      count: exercises.length,
      generatedAt: new Date().toISOString(),
      rawContent: content
    };
  }

  /**
   * 处理试卷生成智能体的响应
   * @param {string} content - 响应内容
   * @returns {object} - 结构化的试卷
   */
  processPaperBotResponse(content) {
    // 提取试卷标题
    const titleMatch = content.match(/^(.+?)(?=\n|$)/);
    const title = titleMatch ? titleMatch[0].trim() : '未命名试卷';
    
    // 提取试卷说明
    const instructionsMatch = content.match(/说明[：:](\s*[\s\S]*?)(?=第[一二三四五]部分|一、|二、|$)/);
    const instructions = instructionsMatch ? instructionsMatch[1].trim() : '';
    
    // 提取试卷部分
    const sections = [];
    const sectionPattern = /(?:第([一二三四五])部分|([一二三四五])、)\s*([^\n]+)(?:[\s\S]*?)(?=第[一二三四五]部分|[一二三四五]、|$)/g;
    
    let sectionMatch;
    while ((sectionMatch = sectionPattern.exec(content)) !== null) {
      const sectionNumber = sectionMatch[1] || sectionMatch[2];
      const sectionTitle = sectionMatch[3].trim();
      const sectionContent = sectionMatch[0].substring(sectionMatch[0].indexOf('\n')).trim();
      
      sections.push({
        number: this.chineseNumberToArabic(sectionNumber),
        title: sectionTitle,
        content: sectionContent
      });
    }
    
    return {
      title,
      instructions,
      sections,
      totalSections: sections.length,
      generatedAt: new Date().toISOString(),
      rawContent: content
    };
  }

  /**
   * 从文本中提取指定部分
   * @param {string} text - 完整文本
   * @param {string} startMarker - 开始标记
   * @param {string|null} endMarker - 结束标记，如果为null则提取到文本末尾
   * @returns {string} - 提取的文本部分
   */
  extractSection(text, startMarker, endMarker) {
    const startIndex = text.indexOf(startMarker);
    if (startIndex === -1) return '';
    
    const startPos = startIndex + startMarker.length;
    
    if (endMarker === null) {
      return text.substring(startPos).trim();
    }
    
    const endIndex = text.indexOf(endMarker, startPos);
    if (endIndex === -1) return text.substring(startPos).trim();
    
    return text.substring(startPos, endIndex).trim();
  }

  /**
   * 将中文数字转换为阿拉伯数字
   * @param {string} chineseNumber - 中文数字
   * @returns {number} - 阿拉伯数字
   */
  chineseNumberToArabic(chineseNumber) {
    const map = {
      '一': 1,
      '二': 2,
      '三': 3,
      '四': 4,
      '五': 5,
      '六': 6,
      '七': 7,
      '八': 8,
      '九': 9,
      '十': 10
    };
    return map[chineseNumber] || 0;
  }
}

module.exports = new CozeClient();